#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright 2010 Google Inc. All Rights Reserved.
# Portions copyright PSF License
#   http://code.activestate.com/recipes/278731-creating-a-daemon-the-python-way/

"""A pm-action hook for setting timezone.

Uses the Google Latitude API and the geonames.org
API to find your cellphones latitude and longitude
and from the determine the timezone you are in,
and then sets the computer's timezone to that.
"""

__author__ = 'jcgregorio@google.com (Joe Gregorio)'


from apiclient.discovery import build

import httplib2
import os
import pickle
import pprint
import subprocess
import sys
import time
import uritemplate

from apiclient.anyjson import simplejson
from apiclient.discovery import build
from apiclient.oauth import FlowThreeLegged
from apiclient.ext.authtools import run
from apiclient.ext.file import Storage

# Uncomment to get detailed logging
# httplib2.debuglevel = 4

# URI Template to convert latitude and longitude into a timezone
GEONAMES = 'http://api.geonames.org/timezoneJSON?lat={lat}&lng={long}&username=jcgregorio'
PID_FILE = '/var/lock/tznever.pid'
CACHE = '/var/local/tznever/.cache'

# Default daemon parameters.
# File mode creation mask of the daemon.
UMASK = 0

# Default working directory for the daemon.
WORKDIR = "/"

# Default maximum for the number of available file descriptors.
MAXFD = 1024

# The standard I/O file descriptors are redirected to /dev/null by default.
if (hasattr(os, "devnull")):
   REDIRECT_TO = os.devnull
else:
   REDIRECT_TO = "/dev/null"


def main():
  storage = Storage('/var/local/tznever/latitude_credentials.dat')
  credentials = storage.get()
  if len(sys.argv) == 1:
    if credentials is None or credentials.invalid == True:
      auth_discovery = build('latitude', 'v1').auth_discovery()
      flow = FlowThreeLegged(auth_discovery,
          consumer_key='m-buzz.appspot.com',
          consumer_secret='NQEHb4eU6GkjjFGe1MD5W6IC',
          user_agent='tz-never/1.0',
          domain='m-buzz.appspot.com',
          scope='https://www.googleapis.com/auth/latitude',
          xoauth_displayname='TZ Never Again',
          location='current',
          granularity='city'
          )

      credentials = run(flow, storage)
    else:
      print "You are already authorized"
  else:
    if credentials is None or credentials.invalid == True:
      print "This app, tznever, is not authorized. Run from the command-line to re-authorize."
      os.exit(1)

  if len(sys.argv) > 1 and sys.argv[1] in ['hibernate', 'suspend']:
    print "Hibernating"
    # Kill off the possibly still running process by its pid
    if os.path.isfile(PID_FILE):
      f = file(PID_FILE, 'r')
      pid = f.read()
      f.close()
      cmdline = ['/bin/kill', '-2', pid]
      subprocess.Popen(cmdline)
      os.unlink(PID_FILE)
  elif len(sys.argv) > 1 and sys.argv[1] in ['thaw', 'resume']:
    print "Resuming"
    # write our pid out
    f = file(PID_FILE, 'w')
    f.write(str(os.getpid()))
    f.close()

    success = False
    first_time = True
    while not success:
      try:
        if not first_time:
          time.sleep(5)
        else:
          first_time = False
          print "Daemonizing so as not to gum up the works."
          createDaemon()
          # rewrite the PID file with our new PID
          f = file(PID_FILE, 'w')
          f.write(str(os.getpid()))
          f.close()
        http = httplib2.Http(CACHE)
        http = credentials.authorize(http)

        service = build('latitude', 'v1', http=http)

        location = service.currentLocation().get(granularity='city').execute()
        position = {
            'lat': str(location['latitude']),
            'long': str(location['longitude'])
            }
        http2 = httplib2.Http(CACHE)
        resp, content = http2.request(uritemplate.expand(GEONAMES, position))
        geodata = simplejson.loads(content)
        tz = geodata['timezoneId']
        f = file('/etc/timezone', 'w')
        f.write(tz)
        f.close()
        cmdline = 'dpkg-reconfigure -f noninteractive tzdata'.split(' ')
        subprocess.Popen(cmdline)
        success = True
      except httplib2.ServerNotFoundError, e:
        print "still not connected, sleeping"
      except KeyboardInterrupt, e:
        if os.path.isfile(PID_FILE):
          os.unlink(PID_FILE)
        success = True
    # clean up pid file
    if os.path.isfile(PID_FILE):
      os.unlink(PID_FILE)


def createDaemon():
   """Detach a process from the controlling terminal and run it in the
   background as a daemon.
   """

   try:
      # Fork a child process so the parent can exit.  This returns control to
      # the command-line or shell.  It also guarantees that the child will not
      # be a process group leader, since the child receives a new process ID
      # and inherits the parent's process group ID.  This step is required
      # to insure that the next call to os.setsid is successful.
      pid = os.fork()
   except OSError, e:
      raise Exception, "%s [%d]" % (e.strerror, e.errno)

   if (pid == 0):	# The first child.
      # To become the session leader of this new session and the process group
      # leader of the new process group, we call os.setsid().  The process is
      # also guaranteed not to have a controlling terminal.
      os.setsid()

      # Is ignoring SIGHUP necessary?
      #
      # It's often suggested that the SIGHUP signal should be ignored before
      # the second fork to avoid premature termination of the process.  The
      # reason is that when the first child terminates, all processes, e.g.
      # the second child, in the orphaned group will be sent a SIGHUP.
      #
      # "However, as part of the session management system, there are exactly
      # two cases where SIGHUP is sent on the death of a process:
      #
      #   1) When the process that dies is the session leader of a session that
      #      is attached to a terminal device, SIGHUP is sent to all processes
      #      in the foreground process group of that terminal device.
      #   2) When the death of a process causes a process group to become
      #      orphaned, and one or more processes in the orphaned group are
      #      stopped, then SIGHUP and SIGCONT are sent to all members of the
      #      orphaned group." [2]
      #
      # The first case can be ignored since the child is guaranteed not to have
      # a controlling terminal.  The second case isn't so easy to dismiss.
      # The process group is orphaned when the first child terminates and
      # POSIX.1 requires that every STOPPED process in an orphaned process
      # group be sent a SIGHUP signal followed by a SIGCONT signal.  Since the
      # second child is not STOPPED though, we can safely forego ignoring the
      # SIGHUP signal.  In any case, there are no ill-effects if it is ignored.
      #
      # import signal           # Set handlers for asynchronous events.
      # signal.signal(signal.SIGHUP, signal.SIG_IGN)

      try:
         # Fork a second child and exit immediately to prevent zombies.  This
         # causes the second child process to be orphaned, making the init
         # process responsible for its cleanup.  And, since the first child is
         # a session leader without a controlling terminal, it's possible for
         # it to acquire one by opening a terminal in the future (System V-
         # based systems).  This second fork guarantees that the child is no
         # longer a session leader, preventing the daemon from ever acquiring
         # a controlling terminal.
         pid = os.fork()	# Fork a second child.
      except OSError, e:
         raise Exception, "%s [%d]" % (e.strerror, e.errno)

      if (pid == 0):	# The second child.
         # Since the current working directory may be a mounted filesystem, we
         # avoid the issue of not being able to unmount the filesystem at
         # shutdown time by changing it to the root directory.
         os.chdir(WORKDIR)
         # We probably don't want the file mode creation mask inherited from
         # the parent, so we give the child complete control over permissions.
         os.umask(UMASK)
      else:
         # exit() or _exit()?  See below.
         os._exit(0)	# Exit parent (the first child) of the second child.
   else:
      # exit() or _exit()?
      # _exit is like exit(), but it doesn't call any functions registered
      # with atexit (and on_exit) or any registered signal handlers.  It also
      # closes any open file descriptors.  Using exit() may cause all stdio
      # streams to be flushed twice and any temporary files may be unexpectedly
      # removed.  It's therefore recommended that child branches of a fork()
      # and the parent branch(es) of a daemon use _exit().
      os._exit(0)	# Exit parent of the first child.

   # Close all open file descriptors.  This prevents the child from keeping
   # open any file descriptors inherited from the parent.  There is a variety
   # of methods to accomplish this task.  Three are listed below.
   #
   # Try the system configuration variable, SC_OPEN_MAX, to obtain the maximum
   # number of open file descriptors to close.  If it doesn't exists, use
   # the default value (configurable).
   #
   # try:
   #    maxfd = os.sysconf("SC_OPEN_MAX")
   # except (AttributeError, ValueError):
   #    maxfd = MAXFD
   #
   # OR
   #
   # if (os.sysconf_names.has_key("SC_OPEN_MAX")):
   #    maxfd = os.sysconf("SC_OPEN_MAX")
   # else:
   #    maxfd = MAXFD
   #
   # OR
   #
   # Use the getrlimit method to retrieve the maximum file descriptor number
   # that can be opened by this process.  If there is not limit on the
   # resource, use the default value.
   #
   import resource		# Resource usage information.
   maxfd = resource.getrlimit(resource.RLIMIT_NOFILE)[1]
   if (maxfd == resource.RLIM_INFINITY):
      maxfd = MAXFD

   # Iterate through and close all file descriptors.
   for fd in range(0, maxfd):
      try:
         os.close(fd)
      except OSError:	# ERROR, fd wasn't open to begin with (ignored)
         pass

   # Redirect the standard I/O file descriptors to the specified file.  Since
   # the daemon has no controlling terminal, most daemons redirect stdin,
   # stdout, and stderr to /dev/null.  This is done to prevent side-effects
   # from reads and writes to the standard I/O file descriptors.

   # This call to open is guaranteed to return the lowest file descriptor,
   # which will be 0 (stdin), since it was closed above.
   os.open(REDIRECT_TO, os.O_RDWR)	# standard input (0)

   # Duplicate standard input to standard output and standard error.
   os.dup2(0, 1)			# standard output (1)
   os.dup2(0, 2)			# standard error (2)

   return(0)

if __name__ == '__main__':
  main()



